

////////////////////////////////////////////////////////////////////////////////////////////////////
/* IntList , DoubleList , Punkt , Element , PunktList , ElementList                               */
////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////
/*                                              IntList                                           */
////////////////////////////////////////////////////////////////////////////////////////////////////

        
class IntList{

int iter,grow,max;

int *Lista;
public:

IntList(int grow1,int max1){iter=0;grow=grow1;max=max1;Lista = new int[max];}
IntList(){iter=0;max=10;grow=5;Lista = new int[max];}

int getIter(){return iter;}
int getM(){return max;}
void setGrow(int grow1){if(grow>1){grow=grow1;}}

void setElement(const int &a);
bool setElementUniqat(const int &a){for(int i=0;i<iter;i++){if(a == Lista[i]){return false;}}setElement(a);return true;}
bool setElementUniqatOddNumbers(const int &a){for(int i=1;i<iter;i+=2){if(a == Lista[i]){return false;}}setElement(a);return true;}
bool setElementUniqatEvenNumbers(const int &a){for(int i=0;i<iter;i+=2){if(a == Lista[i]){return false;}}setElement(a);return true;}
void podmienElement(const int &ktory,const int &a){if(ktory<iter)Lista[ktory]=a;}
int getElement(int ktory){return Lista[ktory];}
int getLastElement(){return Lista[iter-1];}
void czysc(int grow1,int max1){grow=grow1;max=max1; if(Lista!=NULL){delete []Lista; Lista = new int[max];iter=0;}}
void ustawIter(int iter1){iter = iter1;}
void usunElement(const int &ktory){Lista[ktory]=Lista[--iter];}
~IntList(){if(Lista!=NULL){delete []Lista;Lista = NULL;}}

bool sprawdzElement(const int &jaki); //jesli jest zwraca true dodatkowo sprawdza czy jest -1(false)

bool sprCzyJestEleWList(const int &jaki);//jesli jest zwraca false
bool sprawdzCzyJest(const int &jaki){for(int i=0;i<iter;++i){if(Lista[i]==jaki){return true;}}return false;} //zwraca jest zwraca true

void zapisDoPliku(const char *nazwa);
void wczytajZPliku(const char *nazwa);
void zamienIntListy(IntList &a);
void zamienWyzerujIntListy(IntList &a,int grow,int max);
void operator=(IntList &a);
void losowyZmianaMiejsca();


};

void IntList::losowyZmianaMiejsca(){

int temp;

    for(int i=0,p1,p2,ile=iter;i<ile;i++){

    p1=rand()%iter;
    p2=rand()%iter;

    temp = Lista[p1];
    Lista[p1]=Lista[p2];
    Lista[p2]=temp;

    }

}
inline void IntList::operator=(IntList &a){

    iter = a.iter;

        max=a.max;grow=a.grow;
        delete []Lista;
        int *Lista = new int[max];
        memcpy ( Lista , a.Lista , sizeof(int)*iter );

}

inline void IntList::zamienWyzerujIntListy(IntList &a,int grow,int max){
    int *w,it,ma,gr;
    w = Lista; Lista = a.Lista; a.Lista = w;
    it = iter; ma = max; gr = grow;
    iter = a.iter; max = a.max; grow = a.grow;
    a.iter = iter; a.grow = gr; a.max = ma;
    a.czysc(grow,max);
}

inline void IntList::zamienIntListy(IntList &a){
    int *w,it,ma,gr;
    w = Lista; Lista = a.Lista; a.Lista = w;
    it = iter; ma = max; gr = grow;
    iter = a.iter; max = a.max; grow = a.grow;
    a.iter = iter; a.grow = gr; a.max = ma;

}

void IntList::wczytajZPliku(const char *nazwa){

ifstream wczytaj(nazwa);

int ileP;
wczytaj>>ileP;

czysc(0.2*(ileP+2),ileP+2);

    for(int i=0;i<ileP;++i){

        wczytaj>>Lista[i];
        iter++;
    }

wczytaj.close();
}

void IntList::zapisDoPliku(const char *nazwa){

ofstream zapis(nazwa);

zapis<<iter<<endl<<endl;

    for(int i=0;i<iter;i++){

        zapis<<Lista[i]<<endl;

    }

zapis.close();

}


inline bool IntList::sprCzyJestEleWList(const int &jaki){
for(int i=0;i<iter;i++){if(jaki==Lista[i]){return false;}}
return true;
}

inline bool IntList::sprawdzElement(const int &jaki){

    if(jaki!=-1){

	    for(int i=0;i<iter;i++){
            if(jaki==Lista[i]){return false;}
        }

        return true;
    }

    return false;
}

inline void IntList::setElement(const int &a){
        if(max>iter){
        Lista[iter]=a;
        iter++;
        }
        else{
        max = max+grow;
        int *Lista1 = new int[max];
        memcpy ( Lista1 , Lista , sizeof(int)*iter );
        delete []Lista;

        Lista = Lista1;
        Lista[iter] = a;
        iter++;
        }

}


////////////////////////////////////////////////////////////////////////////////////////////////////
/*                                              DoubleList                                        */
////////////////////////////////////////////////////////////////////////////////////////////////////

class DoubleList{

int iter,grow,max;

double *Lista;
public:

DoubleList(int grow1,int max1){iter=0;grow=grow1;max=max1;Lista = new double[max];}
DoubleList(){iter=0;max=10;grow=2;Lista = new double[max];}

int getIter(){return iter;}
void setGrow(int grow1){if(grow>1){grow=grow1;}}

void setElement(const double &a);
void podmienElement(const int &ktory,const double &a){if(ktory<iter)Lista[ktory]=a;}
double getElement(int ktory){return Lista[ktory];}
double getLastElement(){return Lista[iter-1];}
void czysc(const int &grow1,const int &max1){grow=grow1;max=max1; if(Lista!=NULL){delete []Lista; Lista = new double[max];iter=0;}}
void ustawIter(int iter1){iter = iter1;}
void podzielPrzezL(const double &a){for(int i=0;i<iter;i++){Lista[i]/=a;}}
double getSrednia();
double getSuma();


~DoubleList(){if(Lista!=NULL){delete []Lista;Lista = NULL;}}
};

inline double DoubleList::getSrednia(){
double srednia=0;
for(int i=0;i<iter;++i){srednia+=Lista[i];}
return srednia/iter;

}

double DoubleList::getSuma(){

double suma=0;
for(int i=0;i<iter;++i){suma+=Lista[i];}
return suma;

}

inline void DoubleList::setElement(const double &a){
        if(max>iter){
        Lista[iter]=a;
        iter++;
        }
        else{
        max = max+grow;
        double *Lista1 = new double[max];
        memcpy ( Lista1 , Lista , sizeof(double)*iter );
        delete []Lista;

        Lista = Lista1;
        Lista[iter] = a;
        iter++;
        }

}

////////////////////////////////////////////////////////////////////////////////////////////////////
/*                                              Punkt                                             */
////////////////////////////////////////////////////////////////////////////////////////////////////

class Punkt{

char granica;
double x,y,z;

public:

//IntList sasiad;

//void wypiszWsp(TMemo *m1){AnsiString t;t="[ ";t+=x;t+=" -- ";t+=y;t+=" -- ";t+=z;t+=" ]";m1->Lines->Add(t);}

Punkt(){;}
Punkt(double x1,double y1,double z1){x=x1;y=y1;z=z1;granica='a';}

void setPunkt(Punkt a){x=a.getX();y=a.getY();z=a.getZ();granica = a.getGranica();}
void setPunkt(const double &x1,const double &y1,const double &z1){x=x1;y=y1;z=z1;granica='a';}
void setPunkt(const double &x1,const double &y1,const double &z1,const char &g){x=x1;y=y1;z=z1;granica=g;}
void setX(const double &x1){x=x1;}
void setY(const double &y1){y=y1;}
void setZ(const double &z1){z=z1;}
void setXYZ(const double &x1,const double &y1,const double &z1){x=x1;y=y1;z=z1;}


void setGranica(const char &a){granica=a;}
void przesunPunkt(double xX,double yY,double zZ){x+=xX;y+=yY;z+=zZ;}

char getGranica(){return granica;}
double getX(){return x;}
double getY(){return y;}
double getZ(){return z;}

float odlegloscPunktu(Punkt &a1);
float odlegloscPunktuSqrt(Punkt &a1){
return sqrt((x-a1.x)*(x-a1.x))+((y-a1.y)*(y-a1.y))+((z-a1.z)*(z-a1.z));
}


float odlegloscPunktu(const double &x1,const double &y1,const double &z1){return (x-x1)*(x-x1)+(y-y1)*(y-y1)+(z-z1)*(z-z1);}
float odlegloscPunktuSqrt(const double &x1,const double &y1,const double &z1){return sqrt((x-x1)*(x-x1)+(y-y1)*(y-y1)+(z-z1)*(z-z1));}

Punkt & operator*(const double &liczba){x*=liczba;y*=liczba;z*=liczba; return *this;}
void operator=(Punkt &a){x=a.getX();y=a.getY();z=a.getZ();granica = a.getGranica();}
bool operator==(Punkt &a)const{return (x==a.getX()&&y==a.getY()&&z==a.getZ()&&granica&&a.getGranica()) ;}
bool operator!=(Punkt &a)const{return !(*this==a);}

};


float Punkt::odlegloscPunktu(Punkt &a1){
return (x-a1.x)*(x-a1.x)+(y-a1.y)*(y-a1.y)+(z-a1.z)*(z-a1.z);
}


////////////////////////////////////////////////////////////////////////////////////////////////////
/*                                              Element                                           */
////////////////////////////////////////////////////////////////////////////////////////////////////

class Element{


int rodzajZiarna;
int punkty[4];
int elementy[4];
double Sx,Sy,Sz;
float R,StosR_r;
double Ax,Ay,Az;
double uk_val[12];



public:

Element(){rodzajZiarna=-1;elementy[0]=-1;elementy[1]=-1;elementy[2]=-1;elementy[3]=-1;Ax=-1;Ay=-1;Az=-1;Sx=-1;Sy=-1;Sz=-1;R=-1;StosR_r=999999;punkty[0]=-1;punkty[1]=-1;punkty[2]=-1;punkty[3]=-1;}
Element(int p1,int p2,int p3,int p4){punkty[0]=p1;punkty[1]=p2;punkty[2]=p3;punkty[3]=p4;elementy[0]=-1;elementy[1]=-1;elementy[2]=-1;elementy[3]=-1;rodzajZiarna=-1;Ax=-1;Ay=-1;Az=-1;Sx=-1;Sy=-1;Sz=-1;R=-1;StosR_r=999999;}
Element(int p1,int p2,int p3,int p4,double Sx1,double Sy1,double Sz1,float R1,double Ax1,double Ay1,double Az1){punkty[0]=p1;punkty[1]=p2;punkty[2]=p3;punkty[3]=p4;Sx=Sx1;Sy=Sy1;Sz=Sz1;R=R1;elementy[0]=-1;elementy[1]=-1;elementy[2]=-1;elementy[3]=-1;Ax=Ax1;Ay=Ay1;Az=Az1;rodzajZiarna=-1;StosR_r=999999;}


void get_uk_val(int id_gauss,double *uk){id_gauss*=3;uk[0]=uk_val[id_gauss+0];uk[1]=uk_val[id_gauss+1];uk[2]=uk_val[id_gauss+2];}
void set_uk_val(int id_gauss,double *uk){id_gauss*=3;uk_val[id_gauss+0]=uk[0];uk_val[id_gauss+1]=uk[1];uk_val[id_gauss+2]=uk[2];}
void set_uk_val_zero(){for(int i=0;i<12;++i){uk_val[i]=0;}}
void setElement(int p1,int p2,int p3,int p4){punkty[0]=p1;punkty[1]=p2;punkty[2]=p3;punkty[3]=p4;elementy[0]=-1;elementy[1]=-1;elementy[2]=-1;elementy[3]=-1;}
void setElement(int p1,int p2,int p3,int p4,int rodzZ){punkty[0]=p1;punkty[1]=p2;punkty[2]=p3;punkty[3]=p4;elementy[0]=-1;elementy[1]=-1;elementy[2]=-1;elementy[3]=-1;rodzajZiarna=rodzZ;}
void setElement(int p1,int p2,int p3,int p4,double Sx1,double Sy1,double Sz1,float R1,double Ax1,double Ay1,double Az1);
void setElement(int p1,int p2,int p3,int p4,double Sx1,double Sy1,double Sz1,float R1,double Ax1,double Ay1,double Az1,float StosunekR_r);

void setPSO(double Sx1,double Sy1,double Sz1,float R1){Sx=Sx1;Sy=Sy1;Sz=Sz1;R=R1;}
void setSSE(double Ax1,double Ay1,double Az1){Ax=Ax1;Ay=Ay1;Az=Az1;}
void setElementySasiad(int e1,int e2,int e3,int e4){elementy[0]=e1;elementy[1]=e2;elementy[2]=e3;elementy[3]=e4;}

void setRodzajZiarna(int a){rodzajZiarna= a;}
int getRodzajZiarna(){return rodzajZiarna;}

float getStosunekR_r(){return StosR_r;}
void setStosunekR_r(float s){StosR_r=s;}

int getP1(){return punkty[0];}
int getP2(){return punkty[1];}
int getP3(){return punkty[2];}
int getP4(){return punkty[3];}

/*
int getP1(){return punkty[1];}
int getP2(){return punkty[2];}
int getP3(){return punkty[0];}
int getP4(){return punkty[3];}
*/
int getP(int ktory){return punkty[ktory];}
int* getPunkty(){return punkty;}

int getE1(){return elementy[0];}
int getE2(){return elementy[1];}
int getE3(){return elementy[2];}
int getE4(){return elementy[3];}
int getE(int ktory){return elementy[ktory];}

void setE1(int e){elementy[0]=e;}
void setE2(int e){elementy[1]=e;}
void setE3(int e){elementy[2]=e;}
void setE4(int e){elementy[3]=e;}


/* */
void setP1(int p){punkty[0]=p;}
void setP2(int p){punkty[1]=p;}
void setP3(int p){punkty[2]=p;}
void setP4(int p){punkty[3]=p;}

void setAx(double Ax1){Ax=Ax1;}
void setAy(double Ay1){Ay=Ay1;}
void setAz(double Az1){Az=Az1;}

int* getElementy(){return elementy;}

double getSx(){return Sx;}
double getSy(){return Sy;}
double getSz(){return Sz;}

float getR(){return R;}
double getAx(){return Ax;}
double getAy(){return Ay;}
double getAz(){return Az;}

bool podmienPunkt(const int &ktoryNr,const int &);
int getNumerSciany(int p1,int p2,int p3);
bool sprawdzSciane(int numerS,int p1,int p2,int p3);
bool sprawdzCzyJestTakiPunkt(int nrPunktu);

};

inline bool Element::sprawdzCzyJestTakiPunkt(int nrPunktu){
if(nrPunktu == punkty[0] || nrPunktu == punkty[1] || nrPunktu == punkty[2] || nrPunktu == punkty[3]){return true;}
return false;
}

inline bool Element::sprawdzSciane(int numerS,int p1,int p2,int p3){

switch(numerS){

    case 0:
        if((p1 == punkty[3] || p1 == punkty[1] || p1 == punkty[0]) &&
           (p2 == punkty[3] || p2 == punkty[1] || p2 == punkty[0]) &&
           (p3 == punkty[3] || p3 == punkty[1] || p3 == punkty[0])){return true;}
        break;

    case 1:
        if((p1 == punkty[3] || p1 == punkty[2] || p1 == punkty[1]) &&
           (p2 == punkty[3] || p2 == punkty[2] || p2 == punkty[1]) &&
           (p3 == punkty[3] || p3 == punkty[2] || p3 == punkty[1])){return true;}
        break;

    case 2:
        if((p1 == punkty[3] || p1 == punkty[0] || p1 == punkty[2]) &&
           (p2 == punkty[3] || p2 == punkty[0] || p2 == punkty[2]) &&
           (p3 == punkty[3] || p3 == punkty[0] || p3 == punkty[2])){return true;}
        break;

    case 3:
        if((p1 == punkty[0] || p1 == punkty[1] || p1 == punkty[2]) &&
           (p2 == punkty[0] || p2 == punkty[1] || p2 == punkty[2]) &&
           (p3 == punkty[0] || p3 == punkty[1] || p3 == punkty[2])){return true;}
        break;

}

return false;

}


inline int Element::getNumerSciany(int p1,int p2,int p3){

    int sum =p1+p2+p3;

    if(sum == punkty[3]+punkty[1]+punkty[0]){return 0;}
    else if(sum == punkty[3]+punkty[2]+punkty[1]){return 1;}
    else if(sum == punkty[3]+punkty[0]+punkty[2]){return 2;}
    else if(sum == punkty[0]+punkty[1]+punkty[2]){return 3;}
    else{return -1;}

}

inline bool Element::podmienPunkt(const int &staryNumer,const int &nowyNumer){

    if(punkty[0]==staryNumer){punkty[0]=nowyNumer;return true;}
    else if(punkty[1]==staryNumer){punkty[1]=nowyNumer;return true;}
    else if(punkty[2]==staryNumer){punkty[2]=nowyNumer;return true;}
    else if(punkty[3]==staryNumer){punkty[3]=nowyNumer;return true;}

    return false;

}

void Element::setElement(int p1,int p2,int p3,int p4,double Sx1,double Sy1,double Sz1,float R1,double Ax1,double Ay1,double Az1){


punkty[0]=p1;
punkty[1]=p2;
punkty[2]=p3;
punkty[3]=p4;


Sx=Sx1;Sy=Sy1;Sz=Sz1;R=R1;
elementy[0]=-1;
elementy[1]=-1;
elementy[2]=-1;
elementy[3]=-1;
Ax=Ax1;Ay=Ay1;Az=Az1;

}

void Element::setElement(int p1,int p2,int p3,int p4,double Sx1,double Sy1,double Sz1,float R1,double Ax1,double Ay1,double Az1,float StosunekR_r){


punkty[0]=p1;
punkty[1]=p2;
punkty[2]=p3;
punkty[3]=p4;


Sx=Sx1;Sy=Sy1;Sz=Sz1;R=R1;
elementy[0]=-1;
elementy[1]=-1;
elementy[2]=-1;
elementy[3]=-1;
Ax=Ax1;Ay=Ay1;Az=Az1;
StosR_r=StosunekR_r;

}

////////////////////////////////////////////////////////////////////////////////////////////////////
/*                                              Pryzmy                                            */
////////////////////////////////////////////////////////////////////////////////////////////////////

class Pryzm{


int rodzajZiarna;
int punkty[6];

public:

Pryzm(){rodzajZiarna=-1;;}
Pryzm(int p1,int p2,int p3,int p4,int p5,int p6){punkty[0]=p1;punkty[1]=p2;punkty[2]=p3;punkty[3]=p4;punkty[4]=p5;punkty[5]=p6;}


void setElement(int p1,int p2,int p3,int p4,int p5,int p6){punkty[0]=p1;punkty[1]=p2;punkty[2]=p3;punkty[3]=p4;punkty[4]=p5;punkty[5]=p6;}


void setRodzajZiarna(int a){rodzajZiarna= a;}
int getRodzajZiarna(){return rodzajZiarna;}

int getP1(){return punkty[0];}
int getP2(){return punkty[1];}
int getP3(){return punkty[2];}
int getP4(){return punkty[3];}
int getP5(){return punkty[4];}
int getP6(){return punkty[5];}
int* getPunkty(){return punkty;}


/* */
void setP1(int p){punkty[0]=p;}
void setP2(int p){punkty[1]=p;}
void setP3(int p){punkty[2]=p;}
void setP4(int p){punkty[3]=p;}
void setP5(int p){punkty[4]=p;}
void setP6(int p){punkty[5]=p;}


bool podmienPunkt(const int &ktoryNr,const int &nowyNumer);

};

inline bool Pryzm::podmienPunkt(const int &staryNumer,const int &nowyNumer){

    if(punkty[0]==staryNumer){punkty[0]=nowyNumer;return true;}
    else if(punkty[1]==staryNumer){punkty[1]=nowyNumer;return true;}
    else if(punkty[2]==staryNumer){punkty[2]=nowyNumer;return true;}
    else if(punkty[3]==staryNumer){punkty[3]=nowyNumer;return true;}
    else if(punkty[4]==staryNumer){punkty[4]=nowyNumer;return true;}
    else if(punkty[5]==staryNumer){punkty[5]=nowyNumer;return true;}

    return false;

}


////////////////////////////////////////////////////////////////////////////////////////////////////
/*                                              PunktyList                                        */
////////////////////////////////////////////////////////////////////////////////////////////////////

class PunktList{

int iter,grow,max;

Punkt *Lista;
public:

PunktList(int grow1,int max1){iter=0;grow=grow1;max=max1;Lista = new Punkt[max+1];}
PunktList(){iter=0;max=10;grow=5;Lista = new Punkt[max+1];}

int getIter(){return iter;}
void setGrow(int grow1){if(grow>1){grow=grow1;}}

void setElement(const double &x1,const double &y1,const double &z1);
void setElement(const double &x1,const double &y1,const double &z1,const char &g);
bool setElementUniqat(const double &x1,const double &y1,const double &z1,const char &g);
void setElement(Punkt &a);
void zamianaMiejsc(const int &a,const int &b){Lista[iter] = Lista[b];Lista[b]=Lista[a];Lista[a]=Lista[iter];}

void podmienElement(int ktory,Punkt &a){if(ktory<iter){Lista[ktory].setPunkt(a.getX(),a.getY(),a.getZ());}}
void podmienElement(int ktory,const double &x1,const double &y1,const double &z1){if(ktory<iter){Lista[ktory].setPunkt(x1,y1,z1);}}

Punkt &getElement(int ktory){return Lista[ktory];}
Punkt &getLastElement(){return Lista[iter-1];}
Punkt &getLastElement(int odKonca){return Lista[iter-(1+odKonca)];}
void zmianaKolejnosci();
void losowyZmianaMiejsca();
                                    
void czysc(int grow1,int max1){grow=grow1;max=max1; if(Lista!=NULL){delete []Lista; Lista = new Punkt[max];iter=0;}}
void ustawIter(int iter1){iter = iter1;}
void zmienIterO(int iter1){iter += iter1;}
void usunElement(int ktory){Lista[ktory]=Lista[--iter];}
PunktList & operator*(const double &liczba){for(int i=0;i<iter;i++){Lista[i]=Lista[i]*liczba;} return *this;}

void zapisDoPliku(const char *nazwa);
void wczytajZPliku(const char *nazwa,bool tylkoGranica);
void wczytajZPlikuPrzerob(const char *nazwa);

void copyPunktList(PunktList &a);

~PunktList(){if(Lista!=NULL){delete []Lista;Lista = NULL;}}
};


void PunktList::copyPunktList(PunktList &a){

    iter = a.iter;
    grow = a.grow;
    max = a.max;

    delete []Lista;
    Lista = new Punkt[max];

    memcpy ( Lista , a.Lista , sizeof(Punkt)*(iter+1) );

}

inline void PunktList::losowyZmianaMiejsca(){

Punkt temp;

    for(int i=0,p1,p2,ile=iter;i<ile;i++){

    p1=rand()%iter;
    p2=rand()%iter;

    temp = Lista[p1];
    Lista[p1]=Lista[p2];
    Lista[p2]=temp;

    }

}

inline void PunktList::zmianaKolejnosci(){
Punkt temp;

    for(int i=0,ile=iter*0.5;i<ile;i++){

    temp = Lista[i+iter-1-i];
    Lista[i+iter-1-i]=Lista[i];
    Lista[i]=temp;

    }

}

inline void PunktList::setElement(Punkt &a){
        if(max>iter){
        Lista[iter]=a;
        iter++;
        }
        else{
        max = max+grow;
        Punkt *Lista1 = new Punkt[max+1];
        memcpy ( Lista1 , Lista , sizeof(Punkt)*iter );
        delete []Lista;

        Lista = Lista1;
        Lista[iter] = a;
        iter++;
        }

}

inline void PunktList::setElement(const double &x1,const double &y1,const double &z1){
        if(max>iter){
        Lista[iter].setPunkt(x1,y1,z1);
        iter++;
        }
        else{
        max = max+grow;
        Punkt *Lista1 = new Punkt[max+1];
        memcpy ( Lista1 , Lista , sizeof(Punkt)*iter );
        delete []Lista;

        Lista = Lista1;
        Lista[iter].setPunkt(x1,y1,z1);
        iter++;
        }

}



inline void PunktList::setElement(const double &x1,const double &y1,const double &z1,const char &g){
        if(max>iter){
        Lista[iter].setPunkt(x1,y1,z1,g);
        iter++;
        }
        else{
        max = max+grow;
        Punkt *Lista1 = new Punkt[max+1];
        memcpy ( Lista1 , Lista , sizeof(Punkt)*iter );
        delete []Lista;

        Lista = Lista1;
        Lista[iter].setPunkt(x1,y1,z1,g);
        iter++;
        }

}

inline bool PunktList::setElementUniqat(const double &x1,const double &y1,const double &z1,const char &g){

    Punkt temp; temp.setPunkt(x1,y1,z1,'g');
    bool flaga=true;
    for(int i=0;i<iter;++i){if(Lista[i]==temp){flaga=false;}}

    if(flaga){

        if(max>iter){
        Lista[iter].setPunkt(x1,y1,z1,g);
        iter++;
        }
        else{
        max = max+grow;
        Punkt *Lista1 = new Punkt[max+1];
        memcpy ( Lista1 , Lista , sizeof(Punkt)*iter );
        delete []Lista;

        Lista = Lista1;
        Lista[iter].setPunkt(x1,y1,z1,g);
        iter++;
        }

    return true;
    }

return false;

}


void PunktList::zapisDoPliku(const char *nazwa){

ofstream zapis(nazwa);
zapis.precision(20);

zapis<<iter<<endl<<endl;

    for(int i=0;i<iter;i++){

        zapis<<i+1<<"  "<<Lista[i].getX()<<"  "<<Lista[i].getY()<<"  "<<Lista[i].getZ()<<"  "<<Lista[i].getGranica()<<endl;

    }

zapis.close();
}

void PunktList::wczytajZPliku(const char *nazwa,bool tylkoGranica){

ifstream wczytaj(nazwa);
wczytaj.precision(20);
string text;

double xW,yW,zW;
char granicaW;
int ileP;

wczytaj>>ileP;



if(tylkoGranica){

    czysc(int(ileP*0.6),int(ileP*0.6));

    for(int i=0;i<ileP;i++){
    wczytaj>>text;

    wczytaj>>xW;
    wczytaj>>yW;
    wczytaj>>zW;
    wczytaj>>granicaW;


    if(granicaW=='g'){setElement(xW,yW,xW,'g');}
    }

}
else{

    czysc(int(ileP*1.1),int(ileP*1.1));


    for(int i=0;i<ileP;i++){

    wczytaj>>xW;

    wczytaj>>xW;
    wczytaj>>yW;
    wczytaj>>zW;
    wczytaj>>granicaW;

    if(granicaW=='g'){setElement(xW,yW,zW,'g');}
    else{setElement(xW,yW,zW,'a');}

    }

}

wczytaj.close();


}



void PunktList::wczytajZPlikuPrzerob(const char *nazwa){

ifstream wczytaj(nazwa);
wczytaj.precision(20);
string text;

double xW,yW,zW,temp;

    while(1){

    wczytaj>>text;
    if(text!="GRID"){break;}
    wczytaj>>xW;
    wczytaj>>xW;
    wczytaj>>yW;
    wczytaj>>zW;
    wczytaj>>temp;

    setElement(xW*1.5434706,yW*1.5434706,zW*1.5434706);

    }

wczytaj.close();

ofstream zapis("nowePolozenieP.txt");
zapis.precision(12);


    for(int i=0;i<iter;i++){

        zapis<<"GRID"<<"      "<<i+1<<"      "<<Lista[i].getX()<<"      "<<Lista[i].getY()<<"      "<<Lista[i].getZ()<<"  "<<0<<endl;

    }

zapis.close();

}

////////////////////////////////////////////////////////////////////////////////////////////////////
/*                                              ElementyList                                      */
////////////////////////////////////////////////////////////////////////////////////////////////////

class ElementList{

int iter,grow,max;
Element *Lista;

public:



ElementList(int grow1,int max1){iter=0;grow=grow1;max=max1;Lista = new Element[max];}
ElementList(){iter=0;max=10;grow=2;Lista = new Element[max];}

int getIter(){return iter;}
void setGrow(int grow1){if(grow>1){grow=grow1;}}

void setElement(const int &p1,const int &p2,const int &p3,const int &p4);
void setElement(const int &p1,const int &p2,const int &p3,const int &p4,const int &rodzZ);
void setElement(const int &p1,const int &p2,const int &p3,const int &p4,const double &Sx1,const double &Sy1,const double &Sz1,const float &R1,const double &Ax1,const double &Ay1,const double &Az1);
void setElement(const int &p1,const int &p2,const int &p3,const int &p4,const double &Sx1,const double &Sy1,const double &Sz1,const float &R1,const double &Ax1,const double &Ay1,const double &Az1,const float &R_r);
void setElement(Element &a);

void podmienElement(int ktory,Element a){if(ktory<iter)Lista[ktory] = a;}
void podmienElement(int ktory,int p1,int p2,int p3,int p4){if(ktory<iter){Lista[ktory].setElement(p1,p2,p3,p4);}}
void podmienElement(int ktory,int p1,int p2,int p3,int p4,double sx,double sy,double sz,float r,double Ax1,double Ay1,double Az1){if(ktory<iter)Lista[ktory].setElement(p1,p2,p3,p4,sx,sy,sz,r,Ax1,Ay1,Az1);}
void podmienElement(int ktory,int na){if(ktory<iter)Lista[ktory] = Lista[na];}

Element& getElement(int ktory){return Lista[ktory];}
Element& getLastElement(){return Lista[iter-1];}
Element& getLastElement(int odKonca){return Lista[iter-(1+odKonca)];}

void czysc(int grow1,int max1){grow=grow1;max=max1;; delete []Lista; Lista = new Element[max];iter=0;}
void ustaw_ukval_zero(){for(int i=0;i<iter;i++){Lista[i].set_uk_val_zero();}}
void ustawIter(int iter1){iter = iter1;}
void zmienIterO(int iter1){iter += iter1;}
void deleteElement(int ktory){Lista[ktory]=Lista[--iter];}
void deleteElementPodmienS(int ktory);

//wycinanie ziaren
void usunElementyZaz( IntList &nrZazZiaren);
void usunElementyNieZaz( IntList &nrZazZiaren);
void ustawGraniceElementowZaz( IntList &nrZazZiaren);
void ustawGraniceElementowNieZaz( IntList &nrZazZiaren);
void podmienPunktWElementach(const int &staryNumer,const int &nowyNumer,IntList &elementy);
void ustawSasiadow(const int &numerStary,const int &numerNowy);


inline int getNumerSasSacianE1(int nrE);
inline int getNumerSasSacianE2(int nrE);
inline int getNumerSasSacianE3(int nrE);
inline int getNumerSasSacianE4(int nrE);
inline int getNumerSasSacianWybor(int nrE,int nrS);

~ElementList(){if(Lista!=NULL){delete []Lista;Lista = NULL;}}

};

inline int ElementList::getNumerSasSacianE1(int nrE){
	int e = Lista[nrE].getE1();
	if(e==-1){return -1;}
	return Lista[e].getNumerSciany(Lista[nrE].getP4(),Lista[nrE].getP2(),Lista[nrE].getP1());
}

inline int ElementList::getNumerSasSacianE2(int nrE){
	int e = Lista[nrE].getE2();
	if(e==-1){return -1;}
	return Lista[e].getNumerSciany(Lista[nrE].getP4(),Lista[nrE].getP3(),Lista[nrE].getP2());
}

inline int ElementList::getNumerSasSacianE3(int nrE){
	int e = Lista[nrE].getE3();
	if(e==-1){return -1;}
	return Lista[e].getNumerSciany(Lista[nrE].getP4(),Lista[nrE].getP1(),Lista[nrE].getP3());
}

inline int ElementList::getNumerSasSacianE4(int nrE){
	int e = Lista[nrE].getE4();
	if(e==-1){return -1;}
	return Lista[e].getNumerSciany(Lista[nrE].getP1(),Lista[nrE].getP2(),Lista[nrE].getP3());
}

inline int ElementList::getNumerSasSacianWybor(int nrE,int nrS){

	int p1,p2,p3,p4;
	
	p1=Lista[nrE].getP1();
	p2=Lista[nrE].getP2();
	p3=Lista[nrE].getP3();
	p4=Lista[nrE].getP4();
	
	
	switch(nrS){
		case 0:{return Lista[Lista[nrE].getE1()].getNumerSciany(p4,p2,p1);}break;	
		case 1:{return Lista[Lista[nrE].getE2()].getNumerSciany(p4,p3,p2);}break;
		case 2:{return Lista[Lista[nrE].getE3()].getNumerSciany(p4,p1,p3);}break;
		case 3:{return Lista[Lista[nrE].getE4()].getNumerSciany(p1,p2,p3);}break;	
	}

	return -1;
}


void ElementList::ustawSasiadow(const int &numerStary,const int &numerNowy){

    for(int i=0;i<iter;++i){

        if(Lista[i].getE1()==numerStary){Lista[i].setE1(numerNowy);}
        if(Lista[i].getE2()==numerStary){Lista[i].setE2(numerNowy);}
        if(Lista[i].getE3()==numerStary){Lista[i].setE3(numerNowy);}
        if(Lista[i].getE4()==numerStary){Lista[i].setE4(numerNowy);}

    }

}

void ElementList::podmienPunktWElementach(const int &staryNumer,const int &nowyNumer,IntList &elementy){

    for(int i=0,e,ileE=elementy.getIter();i<ileE;++i){

        e=elementy.getElement(i);
        Lista[e].podmienPunkt(staryNumer,nowyNumer);

    }

}

void ElementList::ustawGraniceElementowZaz( IntList &nrZazZiaren){



    for(int i=0,e1,e2,e3,e4;i<iter;++i){

        if(nrZazZiaren.sprawdzCzyJest(Lista[i].getRodzajZiarna())){

            e1=Lista[i].getE1();
            e2=Lista[i].getE2();
            e3=Lista[i].getE3();
			e4=Lista[i].getE4();

            if(e1 !=-1 && !nrZazZiaren.sprawdzCzyJest(Lista[e1].getRodzajZiarna())){Lista[i].setE1(-1);}
            if(e2 !=-1 && !nrZazZiaren.sprawdzCzyJest(Lista[e2].getRodzajZiarna())){Lista[i].setE2(-1);}
            if(e3 !=-1 && !nrZazZiaren.sprawdzCzyJest(Lista[e3].getRodzajZiarna())){Lista[i].setE3(-1);}
			if(e4 !=-1 && !nrZazZiaren.sprawdzCzyJest(Lista[e4].getRodzajZiarna())){Lista[i].setE4(-1);}


        }

    }

}

void ElementList::ustawGraniceElementowNieZaz( IntList &nrZazZiaren){

    for(int i=0,e1,e2,e3,e4;i<iter;++i){

        if(!nrZazZiaren.sprawdzCzyJest(Lista[i].getRodzajZiarna())){

            e1=Lista[i].getE1();
            e2=Lista[i].getE2();
            e3=Lista[i].getE3();
			e4=Lista[i].getE4();

            if(e1 !=-1 && nrZazZiaren.sprawdzCzyJest(Lista[e1].getRodzajZiarna())){Lista[i].setE1(-1);}
            if(e2 !=-1 && nrZazZiaren.sprawdzCzyJest(Lista[e2].getRodzajZiarna())){Lista[i].setE2(-1);}
            if(e3 !=-1 && nrZazZiaren.sprawdzCzyJest(Lista[e3].getRodzajZiarna())){Lista[i].setE3(-1);}
			if(e4 !=-1 && nrZazZiaren.sprawdzCzyJest(Lista[e4].getRodzajZiarna())){Lista[i].setE4(-1);}


        }

    }

}



void ElementList::usunElementyNieZaz( IntList &nrZazZiaren){

    for(int i=0,e1,e2,e3,e4;i<iter;++i){
        if(!nrZazZiaren.sprawdzCzyJest(Lista[i].getRodzajZiarna())){
            --iter;

            if(nrZazZiaren.sprawdzCzyJest(Lista[iter].getRodzajZiarna())){

                Lista[i]=Lista[iter];

                e1=Lista[i].getE1();
                e2=Lista[i].getE2();
                e3=Lista[i].getE3();
				e4=Lista[i].getE4();

                if(e1!=-1){
                    if(iter==Lista[e1].getE1()){Lista[e1].setE1(i);}
                    else if(iter==Lista[e1].getE2()){Lista[e1].setE2(i);}
                    else if(iter==Lista[e1].getE3()){Lista[e1].setE3(i);}
					else if(iter==Lista[e1].getE4()){Lista[e1].setE4(i);}
                }
                if(e2!=-1){
                    if(iter==Lista[e2].getE1()){Lista[e2].setE1(i);}
                    else if(iter==Lista[e2].getE2()){Lista[e2].setE2(i);}
                    else if(iter==Lista[e2].getE3()){Lista[e2].setE3(i);}
					else if(iter==Lista[e2].getE4()){Lista[e2].setE4(i);}
                }
                if(e3!=-1){
                    if(iter==Lista[e3].getE1()){Lista[e3].setE1(i);}
                    else if(iter==Lista[e3].getE2()){Lista[e3].setE2(i);}
                    else if(iter==Lista[e3].getE3()){Lista[e3].setE3(i);}
					else if(iter==Lista[e3].getE4()){Lista[e3].setE4(i);}
                }
                if(e4!=-1){
                    if(iter==Lista[e4].getE1()){Lista[e4].setE1(i);}
                    else if(iter==Lista[e4].getE2()){Lista[e4].setE2(i);}
                    else if(iter==Lista[e4].getE3()){Lista[e4].setE3(i);}
					else if(iter==Lista[e4].getE4()){Lista[e4].setE4(i);}
                }
               
             }

             --i;

        }
    }
   
}


void ElementList::usunElementyZaz( IntList &nrZazZiaren){

    for(int i=0,e1,e2,e3,e4;i<iter;++i){
        if(nrZazZiaren.sprawdzCzyJest(Lista[i].getRodzajZiarna())){

            Lista[i]=Lista[--iter];

            if(!nrZazZiaren.sprawdzCzyJest(Lista[iter].getRodzajZiarna())){

                e1=Lista[i].getE1();
                e2=Lista[i].getE2();
                e3=Lista[i].getE3();
				e4=Lista[i].getE4();

                if(e1!=-1){;
                    if(iter==Lista[e1].getE1()){Lista[e1].setE1(i);}
                    else if(iter==Lista[e1].getE2()){Lista[e1].setE2(i);}
                    else if(iter==Lista[e1].getE3()){Lista[e1].setE3(i);}
					else if(iter==Lista[e1].getE4()){Lista[e1].setE4(i);}
                }
                if(e2!=-1){
                    if(iter==Lista[e2].getE1()){Lista[e2].setE1(i);}
                    else if(iter==Lista[e2].getE2()){Lista[e2].setE2(i);}
                    else if(iter==Lista[e2].getE3()){Lista[e2].setE3(i);}
					else if(iter==Lista[e2].getE4()){Lista[e2].setE4(i);}
                }
                if(e3!=-1){
                    if(iter==Lista[e3].getE1()){Lista[e3].setE1(i);}
                    else if(iter==Lista[e3].getE2()){Lista[e3].setE2(i);}
                    else if(iter==Lista[e3].getE3()){Lista[e3].setE3(i);}
					else if(iter==Lista[e3].getE4()){Lista[e3].setE4(i);}
                }
                if(e4!=-1){
                    if(iter==Lista[e4].getE1()){Lista[e4].setE1(i);}
                    else if(iter==Lista[e4].getE2()){Lista[e4].setE2(i);}
                    else if(iter==Lista[e4].getE3()){Lista[e4].setE3(i);}
					else if(iter==Lista[e4].getE4()){Lista[e4].setE4(i);}
                }
				
            }
            --i;

        }
    }

}





inline void ElementList::deleteElementPodmienS(int ktory){

int przes =--iter;



if(przes>ktory){
    int e1,e2,e3,e4;

    e1=Lista[przes].getE1();
    e2=Lista[przes].getE2();
    e3=Lista[przes].getE3();
    e4=Lista[przes].getE4();

    if(e1!=-1){
           if(Lista[e1].getE1()==przes){Lista[e1].setE1(ktory);}
           else if(Lista[e1].getE2()==przes){Lista[e1].setE2(ktory);}
           else if(Lista[e1].getE3()==przes){Lista[e1].setE3(ktory);}
           else if(Lista[e1].getE4()==przes){Lista[e1].setE4(ktory);}
    }

    if(e2!=-1){
           if(Lista[e2].getE1()==przes){Lista[e2].setE1(ktory);}
           else if(Lista[e2].getE2()==przes){Lista[e2].setE2(ktory);}
           else if(Lista[e2].getE3()==przes){Lista[e2].setE3(ktory);}
           else if(Lista[e2].getE4()==przes){Lista[e2].setE4(ktory);}
    }

    if(e3!=-1){
           if(Lista[e3].getE1()==przes){Lista[e3].setE1(ktory);}
           else if(Lista[e3].getE2()==przes){Lista[e3].setE2(ktory);}
           else if(Lista[e3].getE3()==przes){Lista[e3].setE3(ktory);}
           else if(Lista[e3].getE4()==przes){Lista[e3].setE4(ktory);}
    }

    if(e4!=-1){
           if(Lista[e4].getE1()==przes){Lista[e4].setE1(ktory);}
           else if(Lista[e4].getE2()==przes){Lista[e4].setE2(ktory);}
           else if(Lista[e4].getE3()==przes){Lista[e4].setE3(ktory);}
           else if(Lista[e4].getE4()==przes){Lista[e4].setE4(ktory);}
    }



Lista[ktory]=Lista[przes];

}

}

inline void ElementList::setElement(Element &a){
        if(max>iter){

        Lista[iter]=a;
        iter++;
        }
        else{
        max = max+grow;
        Element *Lista1 = new Element[max];
        memcpy ( Lista1 , Lista , sizeof(Element)*iter );
        delete []Lista;

        Lista = Lista1;
        Lista[iter] = a;
        iter++;
        }

}

inline void ElementList::setElement(const int &p1,const int &p2,const int &p3,const int &p4){
        if(max>iter){
        Lista[iter].setElement(p1,p2,p3,p4);
        iter++;
        }
        else{
        max = max+grow;
        Element *Lista1 = new Element[max];
        memcpy ( Lista1 , Lista , sizeof(Element)*iter );
        delete []Lista;

        Lista = Lista1;
        Lista[iter].setElement(p1,p2,p3,p4);
        iter++;
        }

}

inline void ElementList::setElement(const int &p1,const int &p2,const int &p3,const int &p4,const int &rodzZ){
        if(max>iter){
        Lista[iter].setElement(p1,p2,p3,p4,rodzZ);
        iter++;
        }
        else{
        max = max+grow;
        Element *Lista1 = new Element[max];
        memcpy ( Lista1 , Lista , sizeof(Element)*iter );
        delete []Lista;

        Lista = Lista1;
        Lista[iter].setElement(p1,p2,p3,p4,rodzZ);
        iter++;
        }

}

inline void ElementList::setElement(const int &p1,const int &p2,const int &p3,const int &p4,const double &Sx1,const double &Sy1,const double &Sz1,const float &R1,const double &Ax1,const double &Ay1,const double &Az1){
        if(max>iter){
        Lista[iter].setElement(p1,p2,p3,p4,Sx1,Sy1,Sz1,R1,Ax1,Ay1,Az1);
        iter++;
        }
        else{
        max = max+grow;
        Element *Lista1 = new Element[max];
        memcpy ( Lista1 , Lista , sizeof(Element)*iter );
        delete []Lista;

        Lista = Lista1;
        Lista[iter].setElement(p1,p2,p3,p4,Sx1,Sy1,Sz1,R1,Ax1,Ay1,Az1);
        iter++;
        }

}

inline void ElementList::setElement(const int &p1,const int &p2,const int &p3,const int &p4,const double &Sx1,const double &Sy1,const double &Sz1,const float &R1,const double &Ax1,const double &Ay1,const double &Az1,const float &R_r){
        if(max>iter){
        Lista[iter].setElement(p1,p2,p3,p4,Sx1,Sy1,Sz1,R1,Ax1,Ay1,Az1,R_r);
        iter++;
        }
        else{
        max = max+grow;
        Element *Lista1 = new Element[max];
        memcpy ( Lista1 , Lista , sizeof(Element)*iter );
        delete []Lista;

        Lista = Lista1;
        Lista[iter].setElement(p1,p2,p3,p4,Sx1,Sy1,Sz1,R1,Ax1,Ay1,Az1,R_r);
        iter++;
        }

}


////////////////////////////////////////////////////////////////////////////////////////////////////
/*                                              PryzmList                                      */
////////////////////////////////////////////////////////////////////////////////////////////////////

class PryzmList{

int iter,grow,max;
Pryzm *Lista;

public:



PryzmList(int grow1,int max1){iter=0;grow=grow1;max=max1;Lista = new Pryzm[max];}
PryzmList(){iter=0;max=10;grow=2;Lista = new Pryzm[max];}

int getIter(){return iter;}
void setGrow(int grow1){if(grow>1){grow=grow1;}}

void setElement(const int &p1,const int &p2,const int &p3,const int &p4,const int &p5,const int &p6);
void setElement(Pryzm &a);

void podmienElement(int ktory,Pryzm a){if(ktory<iter)Lista[ktory] = a;}
void podmienElement(int ktory,int p1,int p2,int p3,int p4,int p5,int p6){if(ktory<iter){Lista[ktory].setElement(p1,p2,p3,p4,p5,p6);}}
void podmienElement(int ktory,int na){if(ktory<iter)Lista[ktory] = Lista[na];}

Pryzm& getElement(int ktory){return Lista[ktory];}
Pryzm& getLastElement(){return Lista[iter-1];}
Pryzm& getLastElement(int odKonca){return Lista[iter-(1+odKonca)];}

void czysc(int grow1,int max1){grow=grow1;max=max1;; delete []Lista; Lista = new Pryzm[max];iter=0;}
void ustawIter(int iter1){iter = iter1;}
void zmienIterO(int iter1){iter += iter1;}
void deleteElement(int ktory){Lista[ktory]=Lista[--iter];}



~PryzmList(){if(Lista!=NULL){delete []Lista;Lista = NULL;}}


};



inline void PryzmList::setElement(Pryzm &a){
        if(max>iter){
        Lista[iter]=a;
        iter++;
        }
        else{
        max = max+grow;
        Pryzm *Lista1 = new Pryzm[max];
        memcpy ( Lista1 , Lista , sizeof(Pryzm)*iter );
        delete []Lista;

        Lista = Lista1;
        Lista[iter] = a;
        iter++;
        }

}

inline void PryzmList::setElement(const int &p1,const int &p2,const int &p3,const int &p4,const int &p5,const int &p6){
        if(max>iter){
        Lista[iter].setElement(p1,p2,p3,p4,p5,p6);
        iter++;
        }
        else{
        max = max+grow;
        Pryzm *Lista1 = new Pryzm[max];
        memcpy ( Lista1 , Lista , sizeof(Pryzm)*iter );
        delete []Lista;

        Lista = Lista1;
        Lista[iter].setElement(p1,p2,p3,p4,p5,p6);
        iter++;
        }

}


////////////////////////////////////////////////////////////////////////////////////////////////////
/*                                              Face                                             */
////////////////////////////////////////////////////////////////////////////////////////////////////

class Face{

char faceInEl;
int inEl;
int e1,e2,e3;
int bc;

public:

Face(){;}
Face(const int &ed1,const int &ed2,const int &ed3,const char &faceInEl1,const int &inEl1){e1=ed1;e2=ed2;e3=ed3;faceInEl=faceInEl1;inEl=inEl1;}

void setFace(const Face &a){e1=a.e1;e2=a.e2;e3=a.e3;faceInEl = a.faceInEl;inEl=a.inEl;bc=0;}
void setFace(const int &ed1,const int &ed2,const int &ed3,const char &faceInEl1,const int &inEl1){e1=ed1;e2=ed2;e3=ed3;faceInEl=faceInEl1;inEl=inEl1;bc=0;}
void setFace(const int &ed1,const int &ed2,const int &ed3,const char &faceInEl1,const int &inEl1,const int &bc1){e1=ed1;e2=ed2;e3=ed3;faceInEl=faceInEl1;inEl=inEl1;bc=bc1;}

void setFaceAndEl(const char &a,const int &e){faceInEl=a;inEl=e;}
void setE1(const int &ed1){e1=ed1;}
void setE2(const int &ed2){e2=ed2;}
void setE3(const int &ed3){e3=ed3;}
void setInEl(const int &e){inEl=e;}
void setAllE(const int &ed1,const int &ed2,const int &ed3){e1=ed1;e2=ed2;e3=ed3;}
void setFaceInEl(const char &a){faceInEl=a;}
void setBC(int bc1){bc=bc1;}

char getFaceInEl(){return faceInEl;}
int getEd1(){return e1;}
int getEd2(){return e2;}
int getEd3(){return e3;}
int getInEl(){return inEl;}
int getBC(){return bc;}


void operator=(const Face &a){e1=a.e1;e2=a.e2;e3=a.e3;faceInEl = a.faceInEl;inEl=a.inEl;bc=a.bc;}
bool operator==(const Face &a)const{return (e1==a.e1&&e2==a.e2&&e3==a.e3&&faceInEl==a.faceInEl&&inEl==a.inEl) ;}
bool operator!=(const Face &a)const{return !(*this==a);}

};



////////////////////////////////////////////////////////////////////////////////////////////////////
/*                                         FaceList                                               */
////////////////////////////////////////////////////////////////////////////////////////////////////

class FaceList{

int iter,grow,max;
Face *Lista;

public:

FaceList(int grow1,int max1){iter=0;grow=grow1;max=max1;Lista = new Face[max];}
FaceList(){iter=0;max=10;grow=2;Lista = new Face[max];}

int getIter(){return iter;}
void setGrow(int grow1){if(grow>1){grow=grow1;}}


void setElement(const int &ed1,const int &ed2,const int &ed3,const char &faceInEl1,const int &el);
void setElement(const int &ed1,const int &ed2,const int &ed3,const char &faceInEl1,const int &el,const int &bc);
void setElement(Face &a);

void podmienElement(int ktory,Face a){if(ktory<iter)Lista[ktory] = a;}
void podmienElement(int ktory,const int &ed1,const int &ed2,const int &ed3,const char &faceInEl1,const int &el){if(ktory<iter){Lista[ktory].setFace(ed1,ed2,ed3,faceInEl1,el);}}
void podmienElement(int ktory,int na){if(ktory<iter)Lista[ktory] = Lista[na];}

Face& getElement(int ktory){return Lista[ktory];}
Face& getLastElement(){return Lista[iter-1];}
Face& getLastElement(int odKonca){return Lista[iter-(1+odKonca)];}

void czysc(int grow1,int max1){grow=grow1;max=max1;; delete []Lista; Lista = new Face[max];iter=0;}
void ustawIter(int iter1){iter = iter1;}
void zmienIterO(int iter1){iter += iter1;}
void deleteElement(int ktory){Lista[ktory]=Lista[--iter];}



~FaceList(){if(Lista!=NULL){delete []Lista;Lista = NULL;}}


};



inline void FaceList::setElement(Face &a){
        if(max>iter){
        Lista[iter]=a;
        iter++;
        }
        else{
        max = max+grow;
        Face *Lista1 = new Face[max];
        memcpy ( Lista1 , Lista , sizeof(Face)*iter );
        delete []Lista;

        Lista = Lista1;
        Lista[iter] = a;
        iter++;
        }

}

inline void FaceList::setElement(const int &ed1,const int &ed2,const int &ed3,const char &faceInEl1,const int &el){
        if(max>iter){
        Lista[iter].setFace(ed1,ed2,ed3,faceInEl1,el);
        iter++;
        }
        else{
        max = max+grow;
        Face *Lista1 = new Face[max];
        memcpy ( Lista1 , Lista , sizeof(Face)*iter );
        delete []Lista;

        Lista = Lista1;
        Lista[iter].setFace(ed1,ed2,ed3,faceInEl1,el);
        iter++;
        }

}

inline void FaceList::setElement(const int &ed1,const int &ed2,const int &ed3,const char &faceInEl1,const int &el,const int &bc){
        if(max>iter){
        Lista[iter].setFace(ed1,ed2,ed3,faceInEl1,el,bc);
        iter++;
        }
        else{
        max = max+grow;
        Face *Lista1 = new Face[max];
        memcpy ( Lista1 , Lista , sizeof(Face)*iter );
        delete []Lista;

        Lista = Lista1;
        Lista[iter].setFace(ed1,ed2,ed3,faceInEl1,el,bc);
        iter++;
        }

}



////////////////////////////////////////////////////////////////////////////////////////////////////
/*                                              Edge                                             */
////////////////////////////////////////////////////////////////////////////////////////////////////

class Edge{

int p1,p2,el;

public:

Edge(){;}
Edge(const int &pun1,const int &pun2){p1=pun1;p2=pun2;}

void setEdge(const Edge &a){p1=a.p1;p2=a.p2;el=a.el;}
void setEdge(const int &pun1,const int &pun2,const int &el1){p1=pun1;p2=pun2;el=el1;}

void setP1(const int &pun1){p1=pun1;}
void setP2(const int &pun2){p2=pun2;}
void setEl(const int &el1){el=el1;}

int getP1(){return p1;}
int getP2(){return p2;}
int getEl(){return el;}

void operator=(const Edge &a){p1=a.p1;p2=a.p2;el=a.el;}
bool operator==(const Edge &a)const{return (p1==a.p1&&p2==a.p2&&el==a.el);}
bool operator!=(const Edge &a)const{return !(*this==a);}

};


////////////////////////////////////////////////////////////////////////////////////////////////////
/*                                              EdgeList                                      */
////////////////////////////////////////////////////////////////////////////////////////////////////

class EdgeList{

int iter,grow,max;
Edge *Lista;

public:

EdgeList(int grow1,int max1){iter=0;grow=grow1;max=max1;Lista = new Edge[max];}
EdgeList(){iter=0;max=10;grow=2;Lista = new Edge[max];}

int getIter(){return iter;}
void setGrow(int grow1){if(grow>1){grow=grow1;}}

void setElement(const int &p1,const int &p2,const int &el1);
void setElement(Edge &a);

void podmienElement(int ktory,Edge a){if(ktory<iter)Lista[ktory] = a;}
void podmienElement(int ktory,const int &p1,const int &p2,const int &el1){if(ktory<iter){Lista[ktory].setEdge(p1,p2,el1);}}
void podmienElement(int ktory,int na){if(ktory<iter)Lista[ktory] = Lista[na];}

Edge& getElement(int ktory){return Lista[ktory];}
Edge& getLastElement(){return Lista[iter-1];}
Edge& getLastElement(int odKonca){return Lista[iter-(1+odKonca)];}

void czysc(int grow1,int max1){grow=grow1;max=max1;; delete []Lista; Lista = new Edge[max];iter=0;}
void ustawIter(int iter1){iter = iter1;}
void zmienIterO(int iter1){iter += iter1;}
void deleteElement(int ktory){Lista[ktory]=Lista[--iter];}



~EdgeList(){if(Lista!=NULL){delete []Lista;Lista = NULL;}}


};



inline void EdgeList::setElement(Edge &a){
        if(max>iter){
        Lista[iter]=a;
        iter++;
        }
        else{
        max = max+grow;
        Edge *Lista1 = new Edge[max];
        memcpy ( Lista1 , Lista , sizeof(Edge)*iter );
        delete []Lista;

        Lista = Lista1;
        Lista[iter] = a;
        iter++;
        }

}

inline void EdgeList::setElement(const int &p1,const int &p2,const int &el1){
        if(max>iter){
        Lista[iter].setEdge(p1,p2,el1);
        iter++;
        }
        else{
        max = max+grow;
        Edge *Lista1 = new Edge[max];
        memcpy ( Lista1 , Lista , sizeof(Edge)*iter );
        delete []Lista;

        Lista = Lista1;
        Lista[iter].setEdge(p1,p2,el1);
        iter++;
        }

}

////////////////////////////////////////////////////////////////////////////////////////////////////
/*                                              TemplateList                                      */
////////////////////////////////////////////////////////////////////////////////////////////////////

template <typename TYP> class TLista{

int iter,grow,max;

TYP *Lista;
public:

TLista(int grow1,int max1){iter=0;grow=grow1;max=max1;Lista = new TYP[max];}
TLista(){iter=0;max=10;grow=2;Lista = new TYP[max];}

int getIter(){return iter;}
void setGrow(int grow1){if(grow>1){grow=grow1;}}

void setElement(TYP a);
void podmienElement(int ktory,TYP a){if(ktory<iter)Lista[ktory]=a;}
TYP getElement(int ktory){return Lista[ktory];}
TYP getLastElement(){return Lista[iter-1];}

void czysc(int grow1,int max1){grow=grow1;max=max1; if(Lista!=NULL){delete []Lista; Lista = new TYP[max];iter=0;}}
void ustawIter(int iter1){iter = iter1;}

~TLista(){if(*Lista!=0){delete []Lista;*Lista = 0;}}

};

template<typename TYP> void TLista<TYP>::setElement(TYP a){
        if(max>iter){
        Lista[iter]=a;
        iter++;
        }
        else{
        max = max+grow;
        TYP *Lista1 = new TYP[max];
        memcpy ( Lista1 , Lista , sizeof(TYP)*iter );
        delete []Lista;

        Lista = Lista1;
        Lista[iter] = a;
        iter++;
        }
}

class test{

public:
IntList punkty;

void rysuj();
void zaladujP(int ile);
test(){punkty.setGrow(15000);;}

};

void test::zaladujP(int ile){

        for(int i=0;i<ile;i++){
        punkty.setElement(rand()%1001);
        punkty.setElement(rand()%1001);
        }

}
/*
void test::rysuj(){

glBegin(GL_POINTS); //rysowanie prymitywu
glColor3f(0,0,0);

        for(int i=0;i<punkty.getIter();i+=2){
        glVertex3f(punkty.getElement(i),punkty.getElement(i+1),0);
        }

glEnd(); //koniec rysowania

}
*/
